{
"cells": [
{
"cell_type": "markdown",
"id": "90a8b46d-e730-448f-91bd-455448a404af",
"metadata": {},
"source": [
"# Accelerated Backtesting\n",
"\n",
"## Overview\n",
"There is a trade-off between the accuracy and speed of backtesting. *hftbacktest* provides highly accurate results, but it is relatively slow, making it challenging to quickly test new ideas or optimize parameters through rapid iteration. To improve backtest speed, this approach excludes certain conditions, sacrificing a certain degree of accuracy.\n",
"\n",
"The main performance gain comes from precomputing fill conditions for a given running interval. This includes ignoring both fills in the queue position and the order response latency, enabling backtesting within a single loop iteration. By removing queue position estimation, we eliminate the need to fully replay the market depth feed or process every depth update.\n",
"\n",
"Thus, this approach accounts for feed latency and order entry latency, but not order-response latency. In the fill simulation, queue position is not modeled, so partial fills do not occur—orders are either fully filled when crossed or not filled at all.\n",
"\n",
"While these simplifications can result in a loss of accuracy—particularly in case that queue position fills are critical typically due to large tick sizes—they offer substantial performance gains."
]
},
{
"cell_type": "markdown",
"id": "de657928-c603-4c0a-ab62-b13b6c03c84c",
"metadata": {},
"source": [
"## Fill Conditions\n",
"\n",
"- A **buy** order is eligible to fill when **order price >= best ask** or **order price > sell trade price**. \n",
"- A **sell** order is eligible to fill when **order price <= best bid** or **order price < buy trade price**.\n",
"\n",
"Because queue position is not considered, equality does not count:\n",
"\n",
"- buy price == sell trade price → **not filled**\n",
"- sell price == buy trade price → **not filled**\n",
"\n",
"In short, if the market price crosses the order price (strictly), the order is considered filled.\n",
"\n",
"## Limit Order Fill Prices\n",
"For a given time interval [t_i, t_{i+1}]:\n",
"\n",
"**Bid fill price (applies to buy orders):**\n",
"```\n",
"bid fill price = min(\n",
" lowest best ask at the exchange over the interval,\n",
" (lowest sell trade price + one tick) at the exchange over the interval\n",
")\n",
"```\n",
"An open buy order with **order price >= bid fill price** is considered filled in the interval. \n",
"\n",
"**Ask fill price (applies to sell orders):**\n",
"\n",
"```\n",
"ask fill price = max(\n",
" highest best bid at the exchange over the interval,\n",
" (highest buy trade price - one tick) at the exchange over the interval\n",
")\n",
"```\n",
"An open sell order with **order price <= ask fill price** is considered filled in the interval.\n",
"\n",
"## Order Response Latency\n",
"To maintain a single state (no separate local and exchange state) and utilize a single-loop iteration, this don't account for order response latency. Consequently, all state changes—order acceptance, cancellation, fills, and position updates—are reflected immediately on the local side.\n",
"\n",
"## Preprocessed Data Structure"
]
},
{
"cell_type": "markdown",
"id": "3e294352-2408-4b8f-938f-b32a3bdcffa0",
"metadata": {},
"source": [
"```\n",
" row[t] row[t+1]\n",
"Local\n",
"+-------------------------------------------------------------+----------------------------\n",
"|local_ts[t] |local_ts[t+1]\n",
"| |\n",
"|best_bid[t] |best_bid[t+1]\n",
"|best_ask[t] |best_ask[t+1]\n",
"+-------------------------------------------------------------+---------------------------\n",
"Exchange\n",
"+-------------------------------------------------------------+---------------------------\n",
"| bid_fill[t+1]|\n",
"| ask_fill[t+1]|\n",
"+----------------------------+--------------------------------+---------------------------\n",
"| order entry latency at |order_ack_ts[t] |\n",
"| local_ts[t] | |\n",
"| |best_bid_ack[t] |\n",
"| |best_ask_ack[t] |\n",
"| | |\n",
"| bid_fill_ack[t]| bid_fill_after_ack[t]|\n",
"| ask_fill_ack[t]| ask_fill_after_ack[t]|\n",
"+----------------------------+--------------------------------+---------------------------\n",
"```\n",
"\n",
"The open order which is already acknowledged by the exchange between local_ts[t] to local_ts[t + 1] is filled by bid_fill[t + 1] or ask_fill[t + 1] based on the fill condition we describe above and the local knows it at local_ts[t + 1].\n",
"\n",
"If a user sends a new order at local_ts[t], this order is checked if accepted based on best_bid_ack[t] or best_ask_ack[t] (if it is GTX, or marketable order). And if the limit order is accepted, it is checked if is filled until local_ts[t + 1] by bid_fill_after_ack[t] or ask_fill_after_ack[t]. A user know it at local_ts[t + 1].\n",
"\n",
"If a user sends a cancel order at local_ts[t], the open order is checked if it is filled before cancel request is acknowledge by bid_fill_ack[t] or ask_fill_ack[t]. And also a user know it at local_ts[t + 1].\n",
"\n",
"If order entry latency is high enough that the order request arrives at exchange after local_ts[t + 1], compose the row as shown in the following. \n",
"\n",
"```\n",
"Local\n",
"+------------------------------+-------------------------------------------------------------+-------------\n",
"|local_ts[t] |local_ts[t+1] |local_ts[t+2]\n",
"| | |\n",
"|best_bid[t] |best_bid[t+1] |\n",
"|best_ask[t] |best_ask[t+1] |\n",
"+------------------------------+-------------------------------------------------------------+-------------\n",
"Exchange\n",
"+------------------------------+-------------------------------------------------------------+-------------\n",
"| bid_fill[t+1]| bid_fill[t+2]|\n",
"| ask_fill[t+1]| ask_fill[t+2]|\n",
"+------------------------------+------------------------+------------------------------------+-------------\n",
"| order entry latency at local_ts[t] |order_ack_ts[t] |\n",
"| | |\n",
"| |best_bid_ack[t] |\n",
"| |best_ask_ack[t] |\n",
"| | |\n",
"| bid_fill_ack[t]| bid_fill_after_ack[t]|\n",
"| ask_fill_ack[t]| ask_fill_after_ack[t]|\n",
"+------------------------------+------------------------+---+--------------------------------+-------------\n",
"| | |order_ack_ts[t+1] |\n",
"| | | |\n",
"| | |best_bid_ack[t+1] |\n",
"| | |best_ask_ack[t+1] |\n",
"+------------------------------+----------------------------+--------------------------------+-------------\n",
"| | order entry latency at |order_ack_ts[t+1] |\n",
"| | local_ts[t+1] | |\n",
"| | |best_bid_ack[t+1] |\n",
"| | |best_ask_ack[t+1] |\n",
"| | | |\n",
"| | bid_fill_ack[t+1]| bid_fill_after_ack[t+1]|\n",
"| | ask_fill_ack[t+1]| ask_fill_after_ack[t+1]|\n",
"+------------------------------+----------------------------+--------------------------------+-------------\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "cac062e4-e142-455e-aaf8-e893d62b2c04",
"metadata": {},
"source": [
"## Preprocessing Market Data for Accelerated Backtesting"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "0fc74326-b52f-4a5a-9bc7-e19aa52eb049",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import numba as nb\n",
"from numba import njit\n",
"from numba.experimental import jitclass\n",
"\n",
"INVALID_MIN = 0\n",
"INVALID_MAX = np.iinfo(np.int64).max - 1"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "82490f19-8b5d-41b5-b3f8-4af84744d0e2",
"metadata": {},
"outputs": [],
"source": [
"@jitclass\n",
"class Clock:\n",
" timestamp: nb.int64[:]\n",
" rn: nb.int64\n",
" ts: nb.int64\n",
" \n",
" def __init__(self, timestamp, rn):\n",
" self.timestamp = timestamp\n",
" self.rn = rn\n",
" if self.rn >= len(self.timestamp):\n",
" self.ts = INVALID_MAX\n",
" else:\n",
" self.ts = self.timestamp[self.rn]\n",
"\n",
" def next(self):\n",
" if self.rn == len(self.timestamp) - 1:\n",
" self.ts = INVALID_MAX\n",
" else:\n",
" self.rn += 1\n",
" self.ts = self.timestamp[self.rn]\n",
"\n",
"@njit\n",
"def select_event(timestamps):\n",
" # Finds the earliest timestamped event to process first.\n",
" earliest_ts = INVALID_MAX\n",
" ev = -1\n",
" for i in range(len(timestamps)):\n",
" if timestamps[i] < earliest_ts:\n",
" earliest_ts = timestamps[i]\n",
" ev = i\n",
" return ev"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "19699bb2-223f-4e87-be4a-0412f61ad4f3",
"metadata": {},
"outputs": [],
"source": [
"order_latency_dtype = np.dtype([('req_ts', 'i8'), ('exch_ts', 'i8'), ('resp_ts', 'i8'), ('_padding', 'i8')])\n",
"\n",
"@jitclass\n",
"class IntpOrderLatency:\n",
" rn: nb.int64\n",
" data: nb.from_dtype(order_latency_dtype)[:]\n",
" \n",
" def __init__(self, data):\n",
" self.rn = 0\n",
" self.data = data\n",
" \n",
" def entry(self, timestamp):\n",
" # Returns the order entry latency, interpolated from the order entry latency before the timestamp \n",
" # and the order entry latency after the timestamp.\n",
" while (\n",
" self.rn < len(self.data)\n",
" and self.data[self.rn].req_ts < timestamp\n",
" ):\n",
" self.rn += 1\n",
"\n",
" if self.rn == 0:\n",
" entry_latency = self.data[self.rn].exch_ts - self.data[self.rn].req_ts\n",
" elif self.rn == len(self.data):\n",
" entry_latency = self.data[self.rn - 1].exch_ts - self.data[self.rn - 1].req_ts\n",
" else:\n",
" # todo: Handle negative latency values, which indicate a technical issue \n",
" # (e.g., server overload) that causes the order request to be rejected.\n",
" # Please see https://docs.rs/hftbacktest/latest/hftbacktest/backtest/models/struct.IntpOrderLatency.html\n",
" prev_req_ts = self.data[self.rn - 1].req_ts\n",
" next_req_ts = self.data[self.rn].req_ts\n",
" prev_entry_latency = self.data[self.rn - 1].exch_ts - prev_req_ts\n",
" next_entry_latency = self.data[self.rn].exch_ts - next_req_ts\n",
" \n",
" entry_latency = np.divide(\n",
" next_entry_latency - prev_entry_latency, \n",
" next_req_ts - prev_req_ts\n",
" ) * (timestamp - prev_req_ts) + prev_entry_latency\n",
"\n",
" return entry_latency"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "d98971dc-8b1e-4ab9-9cb0-3309568d562d",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def ack_order(\n",
" tick_size,\n",
" order_ack_ts,\n",
" next_local_ts,\n",
" book_ticker_rn,\n",
" book_ticker_exch_ts,\n",
" book_ticker,\n",
" trades_rn,\n",
" trades_exch_ts,\n",
" trades\n",
"):\n",
" # This function finds the fill prices around order_ack_ts, as well as the best bid and best ask at order_ack_ts.\n",
" # - Fill prices between local_ts[t] and order_ack_ts[t]\n",
" # - Fill prices between order_ack_ts[t] and local_ts[t + n], where local_ts[t + n] > order_ack_ts[t]\n",
" \n",
" # Initializes the values from the last best bid and best ask.\n",
" best_bid_tick = round(book_ticker[book_ticker_rn - 1].bid_px / tick_size)\n",
" ask_fill_tick = ask_fill_tick_ack = best_bid_tick_ack = high_best_bid_tick = best_bid_tick\n",
" best_ask_tick = round(book_ticker[book_ticker_rn - 1].ask_px / tick_size)\n",
" bid_fill_tick = bid_fill_tick_ack = best_ask_tick_ack = low_best_ask_tick = best_ask_tick\n",
" \n",
" high_buy_tick = INVALID_MIN\n",
" low_sell_tick = INVALID_MAX\n",
"\n",
" book_ticker_exch_clock = Clock(book_ticker_exch_ts, book_ticker_rn)\n",
" trades_exch_clock = Clock(trades_exch_ts, trades_rn)\n",
" \n",
" while True:\n",
" ev = select_event(np.asarray([\n",
" book_ticker_exch_clock.ts,\n",
" trades_exch_clock.ts,\n",
" order_ack_ts,\n",
" next_local_ts\n",
" ]))\n",
"\n",
" if ev == -1:\n",
" raise ValueError\n",
" elif ev == 0:\n",
" best_bid_tick = round(book_ticker[book_ticker_exch_clock.rn].bid_px / tick_size)\n",
" best_ask_tick = round(book_ticker[book_ticker_exch_clock.rn].ask_px / tick_size)\n",
"\n",
" if best_bid_tick > high_best_bid_tick:\n",
" high_best_bid_tick = best_bid_tick\n",
" if best_ask_tick < low_best_ask_tick:\n",
" low_best_ask_tick = best_ask_tick\n",
" \n",
" book_ticker_exch_clock.next()\n",
" elif ev == 1:\n",
" side = trades[trades_exch_clock.rn].side\n",
" px_tick = round(trades[trades_exch_clock.rn].px / tick_size)\n",
" \n",
" if side == 1 and px_tick > high_buy_tick:\n",
" high_buy_tick = px_tick\n",
" elif side == -1 and px_tick < low_sell_tick:\n",
" low_sell_tick = px_tick\n",
"\n",
" trades_exch_clock.next()\n",
" elif ev == 2:\n",
" # An order request is acknowledged by the exchange at order_ack_ts[t].\n",
" bid_fill_tick_ack = min(low_sell_tick + 1, low_best_ask_tick)\n",
" ask_fill_tick_ack = max(high_buy_tick - 1, high_best_bid_tick)\n",
" best_bid_tick_ack = best_bid_tick\n",
" best_ask_tick_ack = best_ask_tick\n",
"\n",
" high_buy_tick = INVALID_MIN\n",
" high_best_bid_tick = best_bid_tick\n",
" low_sell_tick = INVALID_MAX\n",
" low_best_ask_tick = best_ask_tick\n",
" \n",
" order_ack_ts = INVALID_MAX\n",
" elif ev == 3:\n",
" # at local_ts[t + n] > order_ack_ts[t]\n",
" bid_fill_tick = min(low_sell_tick + 1, low_best_ask_tick)\n",
" ask_fill_tick = max(high_buy_tick - 1, high_best_bid_tick)\n",
" break\n",
" \n",
" return (\n",
" bid_fill_tick_ack,\n",
" ask_fill_tick_ack,\n",
" best_bid_tick_ack,\n",
" best_ask_tick_ack,\n",
" bid_fill_tick,\n",
" ask_fill_tick\n",
" )"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "13b37f2b-904d-4242-8a91-b2c1d97ed80b",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def preprocess_data(\n",
" tick_size,\n",
" end_ts,\n",
" local_ts,\n",
" book_ticker_exch_ts,\n",
" book_ticker_local_ts,\n",
" book_ticker,\n",
" trades_exch_ts,\n",
" trades,\n",
" order_latency\n",
"):\n",
" # Preprocessed data\n",
" # All prices are in ticks to avoid additional operations to prevent floating-point comparison errors.\n",
" out_t = 0\n",
" out_size = len(local_ts)\n",
" # timestamp at local := local_ts[t]\n",
" out_local_ts = np.empty(out_size, np.int64)\n",
" # best bid at local at local_ts[t]\n",
" out_best_bid_tick = np.empty(out_size, np.int64)\n",
" # best ask at local at local_ts[t]\n",
" out_best_ask_tick = np.empty(out_size, np.int64)\n",
" # bid fill price in ticks for the interval local_ts[t - 1] ~ local_ts[t]\n",
" # any open buy orders during this interval with a price greater than or equal to this price are considered filled.\n",
" out_bid_fill_tick = np.empty(out_size, np.int64)\n",
" # ask fill price in ticks for the interval local_ts[t - 1] ~ local_ts[t]\n",
" # any open sell orders during this interval with a price less than or equal to this price are considered filled.\n",
" out_ask_fill_tick = np.empty(out_size, np.int64)\n",
" # order acknowledgment timestamp at the exchange, when an order is sent at local_ts[t], is defined as order_ack_ts[t].\n",
" out_order_ack_ts = np.empty(out_size, np.int64)\n",
" # bid fill price in ticks for the interval local_ts[t] ~ order_ack_ts[t]\n",
" # any open buy orders during this interval with a price greater than or equal to this price are considered filled.\n",
" out_bid_fill_tick_ack = np.empty(out_size, np.int64)\n",
" # ask fill price in ticks for the interval local_ts[t] ~ order_ack_ts[t]\n",
" # any open sell orders during this interval with a price less than or equal to this price are considered filled.\n",
" out_ask_fill_tick_ack = np.empty(out_size, np.int64)\n",
" # best bid at the exchange at order_ack_ts[t]\n",
" # used to determine whether the order should be accepted (limit or market) or rejected (GTX).\n",
" out_best_bid_tick_ack = np.empty(out_size, np.int64)\n",
" # best ask at the exchange at order_ack_ts[t]\n",
" # used to determine whether the order should be accepted (limit or market) or rejected (GTX).\n",
" out_best_ask_tick_ack = np.empty(out_size, np.int64)\n",
" # bid fill price in ticks for the interval order_ack_ts[t] ~ local_ts[t + n] where local_ts[t + n] > order_ack_ts[t].\n",
" # any open buy orders during this interval with a price greater than or equal to this price are considered filled.\n",
" out_bid_fill_tick_after_ack = np.empty(out_size, np.int64)\n",
" # ask fill price in ticks for the interval order_ack_ts[t] ~ local_ts[t + n] where local_ts[t + n] > order_ack_ts[t].\n",
" # any open sell orders during this interval with a price less than or equal to this price are considered filled.\n",
" out_ask_fill_tick_after_ack = np.empty(out_size, np.int64)\n",
" \n",
" local_best_bid_tick = exch_best_bid_tick = INVALID_MIN\n",
" local_best_ask_tick = exch_best_ask_tick = INVALID_MAX\n",
" high_buy_tick = high_best_bid_tick = INVALID_MIN\n",
" low_sell_tick = low_best_ask_tick = INVALID_MAX\n",
"\n",
" # Initializes the clocks\n",
" # todo: For better accuracy, it also needs to combine the best bid and ask from Level-2 market depth data\n",
" # with the best bid and ask from the book ticker.\n",
" book_ticker_exch_clock = Clock(book_ticker_exch_ts, 0)\n",
" book_ticker_local_clock = Clock(book_ticker_local_ts, 0)\n",
" trades_exch_clock = Clock(trades_exch_ts, 0)\n",
" local_clock = Clock(local_ts, 0)\n",
"\n",
" order_latency_rn = 0\n",
"\n",
" while local_clock.ts <= end_ts:\n",
" # Selects the event to process.\n",
" ev = select_event(np.asarray([\n",
" book_ticker_exch_clock.ts,\n",
" book_ticker_local_clock.ts,\n",
" trades_exch_clock.ts,\n",
" local_clock.ts\n",
" ]))\n",
"\n",
" if ev == -1:\n",
" # Should not happen.\n",
" raise ValueError\n",
" elif ev == 0:\n",
" # Updates the current exchange best bid and best ask.\n",
" exch_best_bid_tick = round(book_ticker[book_ticker_exch_clock.rn].bid_px / tick_size)\n",
" exch_best_ask_tick = round(book_ticker[book_ticker_exch_clock.rn].ask_px / tick_size)\n",
"\n",
" # Updates the highest and lowest best bid and best ask at the exchange.\n",
" if exch_best_bid_tick > high_best_bid_tick:\n",
" high_best_bid_tick = exch_best_bid_tick\n",
" if exch_best_ask_tick < low_best_ask_tick:\n",
" low_best_ask_tick = exch_best_ask_tick\n",
"\n",
" book_ticker_exch_clock.next()\n",
" elif ev == 1:\n",
" # Updates the current local best bid and best ask.\n",
" local_best_bid_tick = round(book_ticker[book_ticker_local_clock.rn].bid_px / tick_size)\n",
" local_best_ask_tick = round(book_ticker[book_ticker_local_clock.rn].ask_px / tick_size)\n",
" \n",
" book_ticker_local_clock.next()\n",
" elif ev == 2:\n",
" side = trades[trades_exch_clock.rn].side\n",
" px_tick = round(trades[trades_exch_clock.rn].px / tick_size)\n",
"\n",
" # Updates the highest and lowest trade at the exchange.\n",
" if side == 1 and px_tick > high_buy_tick:\n",
" high_buy_tick = px_tick\n",
" elif side == -1 and px_tick < low_sell_tick:\n",
" low_sell_tick = px_tick\n",
"\n",
" trades_exch_clock.next()\n",
" elif ev == 3:\n",
" # Records the fill prices in ticks at the exchange between local_ts[t - 1] and local_ts[t].\n",
" out_bid_fill_tick[out_t] = min(low_sell_tick + 1, low_best_ask_tick)\n",
" out_ask_fill_tick[out_t] = max(high_buy_tick - 1, high_best_bid_tick)\n",
"\n",
" high_buy_tick = INVALID_MIN\n",
" high_best_bid_tick = exch_best_bid_tick\n",
" low_sell_tick = INVALID_MAX\n",
" low_best_ask_tick = exch_best_ask_tick\n",
" \n",
" # Records the current local state at local_ts[t].\n",
" out_local_ts[out_t] = local_clock.ts\n",
" out_best_bid_tick[out_t] = local_best_bid_tick\n",
" out_best_ask_tick[out_t] = local_best_ask_tick\n",
"\n",
" # Order acknowledgement timestamp when the exchange receives the order request.\n",
" order_entry_latency = order_latency.entry(local_clock.ts)\n",
" order_ack_ts = local_clock.ts + order_entry_latency\n",
" \n",
" # The next local timestamp after the exchange acknowledges the order request.\n",
" next_local_clock = Clock(local_ts, local_clock.rn)\n",
" while next_local_clock.ts < order_ack_ts:\n",
" next_local_clock.next()\n",
" next_local_ts = next_local_clock.ts\n",
"\n",
" # Computes the fill prices around the order acknowledgment timestamp at the exchange\n",
" # and finds the best bid and best ask at the time of acknowledgment.\n",
" (\n",
" bid_fill_tick_ack,\n",
" ask_fill_tick_ack,\n",
" best_bid_tick_ack,\n",
" best_ask_tick_ack,\n",
" bid_fill_tick,\n",
" ask_fill_tick\n",
" ) = ack_order(\n",
" tick_size,\n",
" order_ack_ts,\n",
" next_local_ts,\n",
" book_ticker_exch_clock.rn + 1,\n",
" book_ticker_exch_ts,\n",
" book_ticker,\n",
" trades_exch_clock.rn + 1,\n",
" trades_exch_ts,\n",
" trades\n",
" )\n",
" \n",
" # Records the values related to the order acknowledgment.\n",
" out_order_ack_ts[out_t] = order_ack_ts\n",
" out_bid_fill_tick_ack[out_t] = bid_fill_tick_ack\n",
" out_ask_fill_tick_ack[out_t] = ask_fill_tick_ack\n",
" out_best_bid_tick_ack[out_t] = best_bid_tick_ack\n",
" out_best_ask_tick_ack[out_t] = best_ask_tick_ack\n",
" out_bid_fill_tick_after_ack[out_t] = bid_fill_tick\n",
" out_ask_fill_tick_after_ack[out_t] = ask_fill_tick\n",
" \n",
" out_t += 1\n",
"\n",
" local_clock.next()\n",
" \n",
" return (\n",
" out_local_ts[:out_t],\n",
" out_best_bid_tick[:out_t],\n",
" out_best_ask_tick[:out_t],\n",
" out_bid_fill_tick[:out_t],\n",
" out_ask_fill_tick[:out_t],\n",
" out_order_ack_ts[:out_t],\n",
" out_bid_fill_tick_ack[:out_t],\n",
" out_ask_fill_tick_ack[:out_t],\n",
" out_best_bid_tick_ack[:out_t],\n",
" out_best_ask_tick_ack[:out_t],\n",
" out_bid_fill_tick_after_ack[:out_t],\n",
" out_ask_fill_tick_after_ack[:out_t]\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "679948fc-af0c-4403-9fed-aa9d44875f7d",
"metadata": {},
"source": [
"## Preprocessing Example\n",
"\n",
"Tardis.dev provides free sample data for the first day of each month."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "6903945e-6f76-473a-802d-d133cd883ca3",
"metadata": {},
"outputs": [],
"source": [
"# !curl -L -o BTCUSDT_incremental_book_L2_20250801.csv.gz https://datasets.tardis.dev/v1/binance-futures/incremental_book_L2/2025/08/01/BTCUSDT.csv.gz\n",
"# !curl -L -o BTCUSDT_trades_20250801.csv.gz https://datasets.tardis.dev/v1/binance-futures/trades/2025/08/01/BTCUSDT.csv.gz\n",
"# !curl -L -o BTCUSDT_book_ticker_20250801.csv.gz https://datasets.tardis.dev/v1/binance-futures/book_ticker/2025/08/01/BTCUSDT.csv.gz"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "f9b0e047-24c6-4fb9-b2ae-acea9cf608f9",
"metadata": {},
"outputs": [],
"source": [
"import polars as pl\n",
"\n",
"def load_book_ticker(file):\n",
" df = pl.read_csv(file)\n",
" exch_ts = df['timestamp'].to_numpy() * 1000\n",
" local_ts = df['local_timestamp'].to_numpy() * 1000\n",
" data = df.select(\n",
" pl.col('ask_amount').alias('ask_qty'),\n",
" pl.col('ask_price').alias('ask_px'),\n",
" pl.col('bid_price').alias('bid_px'),\n",
" pl.col('bid_amount').alias('bid_qty'),\n",
" ).to_numpy(structured=True)\n",
" return exch_ts, local_ts, data\n",
"\n",
"def load_trades(file):\n",
" df = pl.read_csv(file)\n",
" exch_ts = df['timestamp'].to_numpy() * 1000\n",
" local_ts = df['local_timestamp'].to_numpy() * 1000\n",
" data = df.select(\n",
" pl.when(pl.col('side') == 'buy').then(1).otherwise(-1).alias('side'),\n",
" pl.col('price').alias('px'),\n",
" pl.col('amount').alias('qty'),\n",
" ).to_numpy(structured=True)\n",
" return exch_ts, local_ts, data\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "7a67eb2a-caf2-4627-b5af-93bb28dbea86",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Correcting the latency\n",
"Correcting the event order\n",
"Saving to BTCUSDT_20250801.npz\n"
]
}
],
"source": [
"# For demonstration purposes, order latency artificially derived from feed latency is used.\n",
"# For more realistic backtesting, actual order latency data should be used.\n",
"# Please see https://hftbacktest.readthedocs.io/en/latest/tutorials/Order%20Latency%20Data.html\n",
"\n",
"from hftbacktest.data.utils.tardis import convert_fuse\n",
"from hftbacktest.data.utils import feed_order_latency\n",
"\n",
"# First, we convert the Tardis data into the normalized format to use the utility \n",
"# that generates order latency from feed latency.\n",
"# This normalized data will also be used to compare accelerated backtesting \n",
"# (which removes certain conditions) against full backtesting (which includes all conditions).\n",
"convert_fuse(\n",
" 'BTCUSDT_trades_20250801.csv.gz', \n",
" 'BTCUSDT_incremental_book_L2_20250801.csv.gz',\n",
" 'BTCUSDT_book_ticker_20250801.csv.gz',\n",
" tick_size=0.1,\n",
" lot_size=0.001,\n",
" output_filename='BTCUSDT_20250801.npz'\n",
")\n",
"\n",
"# Generates order latency from feed latency.\n",
"# At any given time:\n",
"# - Order entry latency = 4 × feed latency\n",
"# - Order response latency = 3 × feed latency\n",
"# Please see the document for details about the arguments.\n",
"feed_order_latency.generate_order_latency(\n",
" 'BTCUSDT_20250801.npz',\n",
" output_file='feed_order_latency_20250801.npz',\n",
" mul_entry=4,\n",
" mul_resp=3\n",
")\n",
"\n",
"order_latency_data = np.load('feed_order_latency_20250801.npz')['data']\n",
"order_latency = IntpOrderLatency(order_latency_data)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "23a9f1e4-1614-4801-87d8-913f3c2af90f",
"metadata": {},
"outputs": [],
"source": [
"tick_size = 0.1\n",
"lot_size = 0.001"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "5372826c-0f15-4130-8131-d1486903a5dd",
"metadata": {},
"outputs": [],
"source": [
"import datetime\n",
"\n",
"# 0.1 seconds\n",
"running_interval = 100_000_000\n",
"start_ts = int(datetime.datetime(2025, 8, 1, tzinfo=datetime.timezone.utc).timestamp() * 1_000_000_000) + running_interval\n",
"end_ts = int(datetime.datetime(2025, 8, 2, tzinfo=datetime.timezone.utc).timestamp() * 1_000_000_000)\n",
"\n",
"# In the final interval, to compute fill prices after order acknowledgment,\n",
"# a small buffer beyond `end_ts` is necessary.\n",
"local_ts = np.arange(start_ts, end_ts + 100 * running_interval, running_interval)\n",
"\n",
"# Additionally, the following day’s data should be concatenated to compute accurate fill prices for the final interval.\n",
"def concat(a, b):\n",
" ret = []\n",
" for aa, bb in zip(a, b):\n",
" ret.append(np.concatenate([aa, bb], axis=0))\n",
" return ret\n",
" \n",
"# book_ticker = concat(\n",
"# load_book_ticker('BTCUSDT_book_ticker_20250501.csv.gz'),\n",
"# load_book_ticker('BTCUSDT_book_ticker_20250502.csv.gz')\n",
"# )\n",
"# trades = concat(\n",
"# load_trades('BTCUSDT_trades_20250501.csv.gz'),\n",
"# load_trades('BTCUSDT_trades_20250502.csv.gz')\n",
"# )\n",
"\n",
"# For demonstration purposes, a single day of data is used.\n",
"book_ticker = load_book_ticker('BTCUSDT_book_ticker_20250801.csv.gz')\n",
"trades = load_trades('BTCUSDT_trades_20250801.csv.gz')"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "369797d5-9989-4791-bb7b-8730d38e5d75",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 9.12 s, sys: 81.2 ms, total: 9.2 s\n",
"Wall time: 9.17 s\n"
]
}
],
"source": [
"%%time\n",
"\n",
"out = preprocess_data(\n",
" tick_size,\n",
" end_ts,\n",
" local_ts,\n",
" book_ticker[0],\n",
" book_ticker[1],\n",
" book_ticker[2],\n",
" trades[0],\n",
" trades[2],\n",
" order_latency\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "ec446951-eb02-4e24-9223-d7b37ae964df",
"metadata": {},
"outputs": [],
"source": [
"import pyarrow as pa\n",
"import pyarrow.parquet as pq\n",
"\n",
"# Saves the preprocessed data to a Parquet file.\n",
"table = pa.table({\n",
" 'local_ts': out[0],\n",
" 'best_bid_tick': out[1],\n",
" 'best_ask_tick': out[2],\n",
" 'bid_fill_tick': out[3],\n",
" 'ask_fill_tick': out[4],\n",
" 'order_ack_ts': out[5],\n",
" 'bid_fill_tick_ack': out[6],\n",
" 'ask_fill_tick_ack': out[7],\n",
" 'best_bid_tick_ack': out[8],\n",
" 'best_ask_tick_ack': out[9],\n",
" 'bid_fill_tick_after_ack': out[10],\n",
" 'ask_fill_tick_after_ack': out[11]\n",
"})\n",
"\n",
"pq.write_table(table, 'BTCUSDT_20250801.parquet', compression='zstd')"
]
},
{
"cell_type": "markdown",
"id": "2efbc116-a27d-4e42-9d04-12e4d6dd2f71",
"metadata": {},
"source": [
"## Accelerated Backtesting Using Preprocessed Market Data"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "b94d1ee3-72a7-423e-b702-190bd91476bf",
"metadata": {},
"outputs": [],
"source": [
"from hftbacktest.types import record_dtype\n",
"\n",
"@njit\n",
"def accelerated_backtest(\n",
" relative_half_spread,\n",
" skew,\n",
" order_notional_value,\n",
" max_notional_position,\n",
" fee,\n",
" tick_size,\n",
" lot_size,\n",
" local_ts,\n",
" best_bid_tick,\n",
" best_ask_tick,\n",
" bid_fill_tick,\n",
" ask_fill_tick,\n",
" order_ack_ts,\n",
" bid_fill_tick_ack,\n",
" ask_fill_tick_ack,\n",
" best_bid_tick_ack,\n",
" best_ask_tick_ack,\n",
" bid_fill_tick_after_ack,\n",
" ask_fill_tick_after_ack\n",
"):\n",
" # req_bid_tick: bid order price in ticks (limit buy order with GTX) sent to the exchange, before the exchange acknowledges it.\n",
" # req_ask_tick: ask order price in ticks (limit sell order with GTX) sent to the exchange, before the exchange acknowledges it.\n",
" # open_bid_tick: bid order price in ticks acknowledged by the exchange, currently an open order in the market.\n",
" # open_ask_tick: ask order price in ticks acknowledged by the exchange, currently an open order in the market.\n",
" #\n",
" # INVALID_MIN and INVALID_MAX indicate that there are no orders.\n",
" #\n",
" # Example:\n",
" # If req_bid_tick is INVALID_MIN and there is an open bid order, \n",
" # the open bid order will be canceled (if the cancel request reaches the exchange before the order is filled).\n",
" # When an order is filled, its price is set to INVALID_MIN or INVALID_MAX accordingly.\n",
" req_bid_tick = open_bid_tick = INVALID_MIN\n",
" req_ask_tick = open_ask_tick = INVALID_MAX\n",
" # corresponding order quantities.\n",
" open_bid_qty = req_bid_qty = 0.0\n",
" open_ask_qty = req_ask_qty = 0.0\n",
"\n",
" # Initial state.\n",
" balance = 0.0\n",
" position = 0.0\n",
" num_trades = 0\n",
" trading_value = 0.0\n",
" trading_volume = 0.0\n",
"\n",
" # Row index iterator\n",
" t = 0\n",
"\n",
" # State record for stats\n",
" rec_i = 0\n",
" record = np.empty(len(local_ts), record_dtype)\n",
" \n",
" while True:\n",
" #--------------------------------------------------------\n",
" # Local bot logic at `local_ts[t]`.\n",
" mid_tick = (best_bid_tick[t] + best_ask_tick[t]) / 2.0\n",
" mid_px = mid_tick * tick_size\n",
" \n",
" notional_position_value = position * mid_px\n",
" normalized_position = notional_position_value / max_notional_position\n",
"\n",
" relative_bid_depth = relative_half_spread + skew * normalized_position\n",
" relative_ask_depth = relative_half_spread - skew * normalized_position\n",
"\n",
" req_bid_tick = min(np.floor(mid_tick * (1.0 - relative_bid_depth)), best_bid_tick[t])\n",
" req_ask_tick = max(np.ceil(mid_tick * (1.0 + relative_ask_depth)), best_ask_tick[t])\n",
"\n",
" req_bid_qty = req_ask_qty = max(round(order_notional_value / mid_px / lot_size) * lot_size, lot_size)\n",
" \n",
" # If the position exceeds the risk limit (max notional position),\n",
" # no orders shall be open in that direction.\n",
" if normalized_position > 1:\n",
" req_bid_tick = INVALID_MIN\n",
" if normalized_position < -1:\n",
" req_ask_tick = INVALID_MAX\n",
"\n",
" #--------------------------------------------------------\n",
" # Records the current state.\n",
" record[rec_i].timestamp = local_ts[t]\n",
" record[rec_i].price = mid_tick * tick_size\n",
" record[rec_i].position = position\n",
" record[rec_i].balance = balance * tick_size\n",
" record[rec_i].fee = trading_value * tick_size * fee\n",
" record[rec_i].num_trades = num_trades\n",
" record[rec_i].trading_volume = trading_volume\n",
" record[rec_i].trading_value = trading_value * tick_size\n",
" \n",
" rec_i += 1\n",
"\n",
" #--------------------------------------------------------\n",
" # Processes the exchange-side logic (order fill logic).\n",
" \n",
" # If any of the requested order prices differ from the open order's price,\n",
" # it is assumed that the bot sent the order request.\n",
" # The request will be acknowledged and processed at `order_ack_ts[t]`.\n",
" # Otherwise, check if the open order is filled.\n",
" if req_bid_tick != open_bid_tick or req_ask_tick != open_ask_tick:\n",
" # The current time is `order_ack_ts[t]`.\n",
" order_ack_ts_ = order_ack_ts[t]\n",
"\n",
" # If there are open orders with valid prices,\n",
" # checks whether they are filled before accepting the newly requested orders.\n",
" if open_bid_tick > INVALID_MIN and open_bid_tick >= bid_fill_tick_ack[t]:\n",
" execute_value = open_bid_tick * open_bid_qty\n",
" balance -= execute_value\n",
" position += open_bid_qty\n",
" num_trades += 1\n",
" trading_volume += open_bid_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_bid_tick = INVALID_MIN\n",
" if open_ask_tick < INVALID_MAX and open_ask_tick <= ask_fill_tick_ack[t]:\n",
" execute_value = open_ask_tick * open_ask_qty\n",
" balance += execute_value\n",
" position -= open_ask_qty\n",
" num_trades += 1\n",
" trading_volume += open_ask_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_ask_tick = INVALID_MAX\n",
" \n",
" # New orders are treated as GTX. \n",
" # If the requested buy order price is greater than or equal to the best ask,\n",
" # or the requested sell order price is less than or equal to the best bid, \n",
" # the orders are rejected.\n",
" # Invalidates the price if the order is rejected.\n",
" if req_bid_tick >= best_ask_tick_ack[t]:\n",
" req_bid_tick = INVALID_MIN\n",
" if req_ask_tick <= best_bid_tick_ack[t]:\n",
" req_ask_tick = INVALID_MAX\n",
"\n",
" # Updates the open orders to reflect accepted orders.\n",
" open_bid_tick = req_bid_tick\n",
" open_ask_tick = req_ask_tick\n",
" open_bid_qty = req_bid_qty\n",
" open_ask_qty = req_ask_qty\n",
"\n",
" # If there are open orders with valid prices,\n",
" # checks whether they are filled before the next local timestamp (`local_ts[t+n]`)\n",
" # that is greater than the current timestamp (`order_ack_ts[t]`).\n",
" if open_bid_tick > INVALID_MIN and open_bid_tick >= bid_fill_tick_after_ack[t]:\n",
" execute_value = open_bid_tick * open_bid_qty\n",
" balance -= execute_value\n",
" position += open_bid_qty\n",
" num_trades += 1\n",
" trading_volume += open_bid_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_bid_tick = INVALID_MIN\n",
" if open_ask_tick < INVALID_MAX and open_ask_tick <= ask_fill_tick_after_ack[t]:\n",
" execute_value = open_ask_tick * open_ask_qty\n",
" balance += execute_value\n",
" position -= open_ask_qty\n",
" num_trades += 1\n",
" trading_volume += open_ask_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_ask_tick = INVALID_MAX\n",
"\n",
" # The next local timestamp must be greater than the current timestamp (`order_ack_ts[t]`).\n",
" while t < len(local_ts) and local_ts[t] < order_ack_ts_:\n",
" t += 1\n",
" # Breaks if no more rows remain for processing.\n",
" if t == len(local_ts):\n",
" break\n",
" else:\n",
" # Checks if the open orders are filled between two local timestamps.\n",
" # The next row of data contains the bid fill price (in ticks) and ask fill price (in ticks) \n",
" # for that interval (step).\n",
" t += 1\n",
" # Breaks if no more rows remain for processing.\n",
" if t == len(local_ts):\n",
" break\n",
"\n",
" # # If there are open orders with valid prices, checks if they are filled.\n",
" if open_bid_tick > INVALID_MIN and open_bid_tick >= bid_fill_tick[t]:\n",
" execute_value = open_bid_tick * open_bid_qty\n",
" balance -= execute_value\n",
" position += open_bid_qty\n",
" num_trades += 1\n",
" trading_volume += open_bid_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_bid_tick = INVALID_MIN\n",
" if open_ask_tick < INVALID_MAX and open_ask_tick <= ask_fill_tick[t]:\n",
" execute_value = open_ask_tick * open_ask_qty\n",
" balance += execute_value\n",
" position -= open_ask_qty\n",
" num_trades += 1\n",
" trading_volume += open_ask_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_ask_tick = INVALID_MAX\n",
" \n",
" return record[:rec_i]"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "9ceba2fd-236f-411f-bc7e-69eefacdc30e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 541 ms, sys: 95.8 ms, total: 637 ms\n",
"Wall time: 560 ms\n"
]
}
],
"source": [
"%%time\n",
"\n",
"table = pq.read_table('BTCUSDT_20250801.parquet')\n",
"\n",
"local_ts = table['local_ts'].to_numpy()\n",
"best_bid_tick = table['best_bid_tick'].to_numpy()\n",
"best_ask_tick = table['best_ask_tick'].to_numpy()\n",
"bid_fill_tick = table['bid_fill_tick'].to_numpy()\n",
"ask_fill_tick = table['ask_fill_tick'].to_numpy()\n",
"order_ack_ts = table['order_ack_ts'].to_numpy()\n",
"bid_fill_tick_ack = table['bid_fill_tick_ack'].to_numpy()\n",
"ask_fill_tick_ack = table['ask_fill_tick_ack'].to_numpy()\n",
"best_bid_tick_ack = table['best_bid_tick_ack'].to_numpy()\n",
"best_ask_tick_ack = table['best_ask_tick_ack'].to_numpy()\n",
"bid_fill_tick_after_ack = table['bid_fill_tick_after_ack'].to_numpy()\n",
"ask_fill_tick_after_ack = table['ask_fill_tick_after_ack'].to_numpy()\n",
"\n",
"relative_half_spread = 0.00025\n",
"skew = relative_half_spread\n",
"order_notional_value = 50000\n",
"max_notional_position = order_notional_value * 20\n",
"fee_per_value = -0.00005 # 0.005% rebates\n",
"\n",
"record = accelerated_backtest(\n",
" relative_half_spread,\n",
" skew,\n",
" order_notional_value,\n",
" max_notional_position,\n",
" fee_per_value,\n",
" tick_size,\n",
" lot_size,\n",
" local_ts,\n",
" best_bid_tick,\n",
" best_ask_tick,\n",
" bid_fill_tick,\n",
" ask_fill_tick,\n",
" order_ack_ts,\n",
" bid_fill_tick_ack,\n",
" ask_fill_tick_ack,\n",
" best_bid_tick_ack,\n",
" best_ask_tick_ack,\n",
" bid_fill_tick_after_ack,\n",
" ask_fill_tick_after_ack\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "63b9aa1f-3797-4014-a764-288e909bdfa7",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
shape: (1, 11) start end SR Sortino Return MaxDrawdown DailyNumberOfTrades DailyTurnover ReturnOverMDD ReturnOverTrade MaxPositionValue datetime[μs] datetime[μs] f64 f64 f64 f64 f64 f64 f64 f64 f64 2025-08-01 00:00:00 2025-08-02 00:00:00 7.60934 10.894142 0.001196 0.003273 350.0 17.49908 0.365565 0.000068 347732.5629
"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "8d45dd28-8796-4178-9a5e-3cbc330137f7",
"metadata": {},
"source": [
"## Comparison of Backtesting Results with Full Backtesting"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "2699b9aa-3e93-42fd-bdc9-64ea7801b2a6",
"metadata": {},
"outputs": [],
"source": [
"from numba import uint64\n",
"from numba.typed import Dict\n",
"from hftbacktest import (\n",
" GTX,\n",
" LIMIT,\n",
" BUY,\n",
" SELL,\n",
" Recorder,\n",
" BacktestAsset,\n",
" ROIVectorMarketDepthBacktest\n",
")\n",
"from hftbacktest.stats import LinearAssetRecord\n",
"\n",
"@njit\n",
"def basic_mm(\n",
" hbt,\n",
" stat,\n",
" relative_half_spread,\n",
" skew,\n",
" interval,\n",
" order_notional_value,\n",
" max_notional_position,\n",
" grid_num,\n",
" grid_interval_tick\n",
"):\n",
" asset_no = 0\n",
"\n",
" tick_size = hbt.depth(0).tick_size\n",
" lot_size = hbt.depth(0).lot_size\n",
" \n",
" while hbt.elapse(interval) == 0:\n",
" hbt.clear_inactive_orders(asset_no)\n",
"\n",
" skip = False\n",
" orders = hbt.orders(asset_no)\n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" if not order.cancellable:\n",
" skip = True\n",
" break\n",
" if skip:\n",
" continue\n",
" \n",
" depth = hbt.depth(asset_no)\n",
" position = hbt.position(asset_no)\n",
" \n",
" mid_tick = (depth.best_bid_tick + depth.best_ask_tick) / 2.0\n",
" mid_px = mid_tick * tick_size\n",
"\n",
" #--------------------------------------------------------\n",
" # Computes bid price and ask price.\n",
" \n",
" notional_position_value = position * mid_px\n",
" normalized_position = notional_position_value / max_notional_position\n",
"\n",
" relative_bid_depth = relative_half_spread + skew * normalized_position\n",
" relative_ask_depth = relative_half_spread - skew * normalized_position\n",
"\n",
" bid_price_tick = min(np.floor(mid_tick * (1.0 - relative_bid_depth)), depth.best_bid_tick)\n",
" ask_price_tick = max(np.ceil(mid_tick * (1.0 + relative_ask_depth)), depth.best_ask_tick)\n",
"\n",
" order_qty = max(round(order_notional_value / mid_px / lot_size) * lot_size, lot_size)\n",
" \n",
" #--------------------------------------------------------\n",
" # Updates quotes.\n",
" \n",
" # Creates a new grid for buy orders.\n",
" new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
" if normalized_position < 1:\n",
" for i in range(grid_num):\n",
" # order price in tick is used as order id.\n",
" new_bid_orders[uint64(bid_price_tick)] = bid_price_tick * tick_size\n",
" \n",
" bid_price_tick -= grid_interval_tick\n",
"\n",
" # Creates a new grid for sell orders.\n",
" new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
" if normalized_position > -1:\n",
" for i in range(grid_num):\n",
" # order price in tick is used as order id.\n",
" new_ask_orders[uint64(ask_price_tick)] = ask_price_tick * tick_size\n",
"\n",
" ask_price_tick += grid_interval_tick\n",
" \n",
" order_values = orders.values();\n",
" while order_values.has_next():\n",
" order = order_values.get()\n",
" # Cancels if a working order is not in the new grid.\n",
" if order.cancellable:\n",
" if (\n",
" (order.side == BUY and order.order_id not in new_bid_orders)\n",
" or (order.side == SELL and order.order_id not in new_ask_orders)\n",
" ):\n",
" hbt.cancel(asset_no, order.order_id, False)\n",
" \n",
" for order_id, order_price in new_bid_orders.items():\n",
" # Posts a new buy order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" for order_id, order_price in new_ask_orders.items():\n",
" # Posts a new sell order if there is no working order at the price on the new grid.\n",
" if order_id not in orders:\n",
" hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
" \n",
" # Records the current state for stat calculation.\n",
" stat.record(hbt)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "4fa35bbd-3db9-4417-9eff-6fd6ac21efb1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 1min 45s, sys: 3.73 s, total: 1min 49s\n",
"Wall time: 1min 49s\n"
]
}
],
"source": [
"%%time\n",
"\n",
"roi_lb = 50000\n",
"roi_ub = 150000\n",
"\n",
"grid_num = 1\n",
"grid_interval_tick = 1\n",
"\n",
"asset = (\n",
" BacktestAsset()\n",
" .data(['BTCUSDT_20250801.npz'])\n",
" .linear_asset(1.0) \n",
" .intp_order_latency(['feed_order_latency_20250801.npz'])\n",
" .power_prob_queue_model(3)\n",
" .no_partial_fill_exchange()\n",
" .trading_value_fee_model(-0.00005, 0.0007)\n",
" .tick_size(0.1)\n",
" .lot_size(0.001)\n",
" .roi_lb(roi_lb) \n",
" .roi_ub(roi_ub)\n",
")\n",
"\n",
"hbt = ROIVectorMarketDepthBacktest([asset])\n",
"\n",
"recorder = Recorder(1, 60_000_000)\n",
"\n",
"basic_mm(\n",
" hbt,\n",
" recorder.recorder,\n",
" relative_half_spread,\n",
" skew,\n",
" running_interval,\n",
" order_notional_value,\n",
" max_notional_position,\n",
" grid_num,\n",
" grid_interval_tick\n",
")\n",
"\n",
"_ = hbt.close()"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "409de936-1167-47fb-b9bd-0cf8e86ec610",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
shape: (1, 11) start end SR Sortino Return MaxDrawdown DailyNumberOfTrades DailyTurnover ReturnOverMDD ReturnOverTrade MaxPositionValue datetime[μs] datetime[μs] f64 f64 f64 f64 f64 f64 f64 f64 f64 2025-08-01 00:00:00 2025-08-01 23:59:59 7.033126 10.104532 0.00119 0.00299 348.004028 17.399667 0.397857 0.000068 349253.6362
"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "2d916a30-c563-441a-ab50-8ce301bdf028",
"metadata": {},
"source": [
"Firstly, accelerated backtest: 416 ms; full backtest: 1 min 49 s — roughly 260× faster.\n",
"\n",
"You can see that there are differences in the detailed numbers, but overall, the results show similar characteristics in terms of position and equity. The differences can become larger depending on the strategy’s characteristics—especially, as mentioned earlier, for assets where fills in the queue is crucial, such as those with a large tick size. Therefore, it is still important to verify the results from accelerated backtesting against those from full backtesting."
]
},
{
"cell_type": "markdown",
"id": "b956a9e1-8a97-400b-840d-2b40f367f86d",
"metadata": {},
"source": [
"## Precompute Signal - Order Book Imbalance\n",
"\n",
"Similarly, precomputing the signal speeds up backtesting and allows rapid iteration to test ideas and tune parameters."
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "e82d131b-8c1d-4227-8ba7-a4c009847266",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def depth_below(depth, start, end, roi_lb_tick):\n",
" for i in range(start, end - 1, -1):\n",
" if depth[i - roi_lb_tick] > 0:\n",
" return i\n",
" return INVALID_MIN\n",
"\n",
"\n",
"@njit\n",
"def depth_above(depth, start, end, roi_lb_tick):\n",
" for i in range(start, end + 1):\n",
" if depth[i - roi_lb_tick] > 0:\n",
" return i\n",
" return INVALID_MAX\n",
"\n",
"@njit\n",
"def precompute_obi(\n",
" tick_size,\n",
" lot_size,\n",
" roi_lb,\n",
" roi_ub,\n",
" end_ts,\n",
" local_ts, \n",
" depth_local_ts,\n",
" depth,\n",
" depth_range\n",
"):\n",
" roi_lb_tick = round(roi_lb / tick_size)\n",
" roi_ub_tick = round(roi_ub / tick_size)\n",
" bid_depth = np.zeros(roi_ub_tick - roi_lb_tick, np.float64)\n",
" ask_depth = np.zeros(roi_ub_tick - roi_lb_tick, np.float64)\n",
"\n",
" best_bid_tick = INVALID_MIN\n",
" best_ask_tick = INVALID_MAX\n",
" low_bid_tick = INVALID_MAX\n",
" high_ask_tick = INVALID_MIN\n",
" \n",
" depth_local_clock = Clock(depth_local_ts, 0)\n",
" local_clock = Clock(local_ts, 0)\n",
"\n",
" out_t = 0\n",
" out_mid_tick = np.empty(len(local_ts), np.float64)\n",
" out_bid_qty = np.empty((len(local_ts), len(depth_range)), np.float64)\n",
" out_bid_weighted = np.empty((len(local_ts), len(depth_range)), np.float64)\n",
" out_ask_qty = np.empty((len(local_ts), len(depth_range)), np.float64)\n",
" out_ask_weighted = np.empty((len(local_ts), len(depth_range)), np.float64)\n",
" \n",
" while local_clock.ts <= end_ts:\n",
" ev = select_event(np.asarray([\n",
" depth_local_clock.ts,\n",
" local_clock.ts\n",
" ]))\n",
"\n",
" if ev == -1:\n",
" raise ValueError\n",
" elif ev == 0:\n",
" # Builds the market depth.\n",
" side = depth[depth_local_clock.rn].side\n",
" px_tick = round(depth[depth_local_clock.rn].px / tick_size)\n",
"\n",
" # Skips processing if the depth update price falls outside the defined range of interest.\n",
" if px_tick > roi_ub_tick or px_tick < roi_lb_tick:\n",
" depth_local_clock.next()\n",
" continue\n",
" \n",
" qty = depth[depth_local_clock.rn].qty\n",
" qty_lot = round(qty / lot_size)\n",
" \n",
" if side == 1:\n",
" bid_depth[px_tick - roi_lb_tick] = qty\n",
" if px_tick < low_bid_tick:\n",
" low_bid_tick = px_tick\n",
" if px_tick > best_bid_tick and qty_lot > 0:\n",
" # Updates the best bid if the bid price is higher than the current best bid.\n",
" best_bid_tick = px_tick\n",
" if best_bid_tick >= best_ask_tick:\n",
" # When the best bid is greater than or equal to the best ask,\n",
" # updates the best ask to the lowest ask above the new best bid.\n",
" best_ask_tick = depth_above(ask_depth, best_bid_tick + 1, high_ask_tick, roi_lb_tick)\n",
" elif px_tick == best_bid_tick and qty_lot == 0:\n",
" # Finds the new best bid if the current best bid is deleted.\n",
" best_bid_tick = depth_below(bid_depth, px_tick, low_bid_tick, roi_lb_tick)\n",
" else:\n",
" ask_depth[px_tick - roi_lb_tick] = qty\n",
" if px_tick > high_ask_tick:\n",
" high_ask_tick = px_tick\n",
" if px_tick < best_ask_tick and qty_lot > 0:\n",
" # Updates the best ask if the ask price is lower than the current best ask.\n",
" best_ask_tick = px_tick\n",
" if best_ask_tick <= best_bid_tick:\n",
" # When the best ask is less than or equal to the best bid,\n",
" # updates the best bid to the highest bid below the new best ask.\n",
" best_bid_tick = depth_below(bid_depth, best_ask_tick - 1, low_bid_tick, roi_lb_tick)\n",
" elif px_tick == best_ask_tick and qty_lot == 0:\n",
" # Finds the best ask if the current best ask is deleted.\n",
" best_ask_tick = depth_above(ask_depth, px_tick, high_ask_tick, roi_lb_tick)\n",
"\n",
" depth_local_clock.next()\n",
" elif ev == 1:\n",
" if best_bid_tick == INVALID_MIN or best_ask_tick == INVALID_MAX:\n",
" mid_tick = np.nan\n",
" out_bid_qty[out_t, :] = np.nan\n",
" out_bid_weighted[out_t, :] = np.nan\n",
" out_ask_qty[out_t, :] = np.nan\n",
" out_ask_weighted[out_t, :] = np.nan\n",
" else:\n",
" mid_tick = (best_bid_tick + best_ask_tick) / 2\n",
" \n",
" # Computes the order book imbalance for the depth range from the mid-price.\n",
" # Please see https://hftbacktest.readthedocs.io/en/latest/tutorials/Market%20Making%20with%20Alpha%20-%20Order%20Book%20Imbalance.html\n",
" #\n",
" # To compute order-book imbalance values, aggregate over depth levels d, where d\n",
" # denotes the tick distance from the mid price; d is symmetric from the mid tick.\n",
" # mid_tick, Sum{Q_bid[d]}, Sum{Q_ask[d]}, Sum{d * Q_bid[d]}, Sum{d * Q_ask[d]}\n",
" #\n",
" # VAMP = (Sum{P_bid[d] * Q_ask[d]} + Sum{P_ask[d] * Q_bid[d]}) / (Sum{Q_bid[d]} + Sum{Q_ask[d]})\n",
" # = tick_size * (mid_tick * Sum{Q_ask[d]} - Sum{d * Q_ask[d]} + mid_tick * Sum{Q_bid[d]} + Sum{d * Q_bid[d]})\n",
" # / (Sum{Q_bid[d]} + Sum{Q_ask[d]})\n",
" #\n",
" # Bid_effective = Sum{P_bid[d] * Q_bid[d]} / Sum{Q_bid[d]}\n",
" # = tick_size * (mid_tick * Sum{Q_bid[d]} - Sum{d * Q_bid[d]}) / Sum{Q_bid[d]}\n",
" # Ask_effective = Sum{P_ask[d] * Q_ask[d]} / Sum{Q_ask[d]}\n",
" # = tick_size * (mid_tick * Sum{Q_ask[d]} + Sum{d * Q_ask[d]}) / Sum{Q_ask[d]}\n",
" i = 0\n",
" bid_qty = 0.0\n",
" bid_weighted = 0.0\n",
" for d in range(best_bid_tick, low_bid_tick - 1, -1):\n",
" bid_qty += bid_depth[d - roi_lb_tick]\n",
" bid_weighted += bid_depth[d - roi_lb_tick] * (mid_tick - d)\n",
" \n",
" if d < mid_tick * (1 - depth_range[i]):\n",
" out_bid_qty[out_t, i] = bid_qty\n",
" out_bid_weighted[out_t, i] = bid_weighted\n",
" i += 1\n",
" if i == len(depth_range):\n",
" break\n",
" \n",
" i = 0\n",
" ask_qty = 0.0\n",
" ask_weighted = 0.0\n",
" for d in range(best_ask_tick, high_ask_tick + 1):\n",
" ask_qty += ask_depth[d - roi_lb_tick]\n",
" ask_weighted += ask_depth[d - roi_lb_tick] * (d - mid_tick)\n",
" \n",
" if d > mid_tick * (1 + depth_range[i]):\n",
" out_ask_qty[out_t, i] = ask_qty\n",
" out_ask_weighted[out_t, i] = ask_weighted\n",
" i += 1\n",
" if i == len(depth_range):\n",
" break\n",
"\n",
" out_mid_tick[out_t] = mid_tick\n",
" \n",
" out_t += 1\n",
" \n",
" local_clock.next()\n",
" return out_mid_tick[:out_t], out_bid_qty[:out_t], out_bid_weighted[:out_t], out_ask_qty[:out_t], out_ask_weighted[:out_t]"
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "6a9791c2-fd21-482a-bb5f-07a9b6bb3da5",
"metadata": {},
"outputs": [],
"source": [
"def load_incremental_book(file):\n",
" df = pl.read_csv(file)\n",
" exch_ts = df['timestamp'].to_numpy() * 1000\n",
" local_ts = df['local_timestamp'].to_numpy() * 1000\n",
" data = df.select(\n",
" pl.col('is_snapshot').cast(pl.Int32),\n",
" pl.when(pl.col('side') == 'bid').then(1).otherwise(-1).alias('side'),\n",
" pl.col('price').alias('px'),\n",
" pl.col('amount').alias('qty'),\n",
" ).to_numpy(structured=True)\n",
" return exch_ts, local_ts, data\n",
"\n",
"# Because the BTCUSDT market depth data is very large, converting it using Polars often crashes due to memory limits.\n",
"# Parsing directly in Python is slower but uses less memory.\n",
"import gzip\n",
"\n",
"def load_incremental_book(file, buffer_size=200_000_000):\n",
" depth_dtype = np.dtype([\n",
" ('is_snapshot', np.int32),\n",
" ('side', np.int32),\n",
" ('px', np.float64),\n",
" ('qty', np.float64)\n",
" ])\n",
" \n",
" exch_ts = np.empty(buffer_size, np.int64)\n",
" local_ts = np.empty(buffer_size, np.int64)\n",
" data = np.empty(buffer_size, depth_dtype)\n",
" with gzip.open(file) as f:\n",
" header = True\n",
" i = 0\n",
" while True:\n",
" line = f.readline()\n",
" if not line:\n",
" break\n",
" if header:\n",
" header = False\n",
" continue\n",
" columns = line.decode().split(',')\n",
" if i == buffer_size:\n",
" raise MemoryError('Not enough buffer size to load data')\n",
" exch_ts[i] = int(columns[2]) * 1000\n",
" local_ts[i] = int(columns[3]) * 1000\n",
" data[i][0] = 1 if columns[4] == 'true' else 0\n",
" data[i][1] = 1 if columns[5] == 'bid' else -1\n",
" data[i][2] = float(columns[6])\n",
" data[i][3] = float(columns[7])\n",
" i += 1\n",
" return exch_ts[:i], local_ts[:i], data[:i]"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "1b755e51-a563-4431-9ad8-a1cc094274ad",
"metadata": {},
"outputs": [],
"source": [
"depth = load_incremental_book('BTCUSDT_incremental_book_L2_20250801.csv.gz')\n",
"\n",
"local_ts = np.arange(start_ts, end_ts + running_interval, running_interval)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "131d4e29-8459-4fb8-b101-e55abc4cdbca",
"metadata": {},
"outputs": [],
"source": [
"roi_lb = 50000\n",
"roi_ub = 150000\n",
"\n",
"depth_range = np.asarray([0.0025, 0.005, 0.0075, 0.01, 0.015, 0.02, 0.025, 0.03])\n",
"\n",
"(\n",
" out_mid_tick,\n",
" out_bid_qty,\n",
" out_bid_weighted,\n",
" out_ask_qty,\n",
" out_ask_weighted\n",
") = precompute_obi(\n",
" tick_size,\n",
" lot_size,\n",
" roi_lb,\n",
" roi_ub,\n",
" end_ts,\n",
" local_ts, \n",
" depth[1],\n",
" depth[2],\n",
" depth_range\n",
")\n",
"\n",
"table_def = {\n",
" 'local_ts': local_ts,\n",
" 'mid_tick': out_mid_tick\n",
"}\n",
"for i, d in enumerate(depth_range):\n",
" table_def[f'bid_qty_{d}'] = out_bid_qty[:, i]\n",
" table_def[f'bid_weighted_{d}'] = out_bid_weighted[:, i]\n",
" table_def[f'ask_qty_{d}'] = out_ask_qty[:, i]\n",
" table_def[f'ask_weighted_{d}'] = out_ask_weighted[:, i]\n",
"\n",
"pq.write_table(pa.table(table_def), f'BTCUSDT_obi_20250801.parquet', compression='zstd')"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "02f96fd4-0625-4faf-8f26-b9a54c020a8d",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_17848/2337632004.py:20: RuntimeWarning: invalid value encountered in divide\n",
" vamp = np.divide(\n",
"/tmp/ipykernel_17848/2337632004.py:28: RuntimeWarning: invalid value encountered in divide\n",
" bid_eff = tick_size * (mid_tick * bid_qty - bid_weighted) / bid_qty\n",
"/tmp/ipykernel_17848/2337632004.py:29: RuntimeWarning: invalid value encountered in divide\n",
" ask_eff = tick_size * (mid_tick * ask_qty + ask_weighted) / ask_qty\n"
]
}
],
"source": [
"table = pq.read_table('BTCUSDT_obi_20250801.parquet')\n",
"local_ts = table['local_ts'].to_numpy()\n",
"mid_tick = table['mid_tick'].to_numpy()\n",
"\n",
"# VAMP = (Sum{P_bid[d] * Q_ask[d]} + Sum{P_ask[d] * Q_bid[d]}) / (Sum{Q_bid[d]} + Sum(Q_ask[d])}\n",
"# Sum{P_bid[d] * Q_ask[d]} + Sum{P_ask[d] * Q_bid[d]} \n",
"# = tick_size * (mid_tick * Sum{Q_ask[d]} - Sum{d * Q_ask[d]} + mid_tick * Sum{Q_bid[d]} + Sum{d * Q_bid[d]})\n",
"#\n",
"# P_effective_bid = Sum{P_bid[d] * Q_bid[d]} / Sum{Q_bid[d]}\n",
"# Sum{P_bid[d] * Q_bid[d]}\n",
"# = tick_size * (mid_tick * Sum{Q_bid[d]} - Sum{d * Q_bid[d]})\n",
"\n",
"depth_range = 0.005\n",
"\n",
"bid_qty = table[f'bid_qty_{depth_range}'].to_numpy()\n",
"ask_qty = table[f'ask_qty_{depth_range}'].to_numpy()\n",
"bid_weighted = table[f'bid_weighted_{depth_range}'].to_numpy()\n",
"ask_weighted = table[f'ask_weighted_{depth_range}'].to_numpy()\n",
"\n",
"vamp = np.divide(\n",
" tick_size * (\n",
" mid_tick * ask_qty - ask_weighted\n",
" + mid_tick * bid_qty + bid_weighted\n",
" ),\n",
" bid_qty + ask_qty\n",
")\n",
"\n",
"bid_eff = tick_size * (mid_tick * bid_qty - bid_weighted) / bid_qty\n",
"ask_eff = tick_size * (mid_tick * ask_qty + ask_weighted) / ask_qty\n",
"vamp_eff = np.divide(\n",
" bid_eff * ask_qty + ask_eff * bid_qty,\n",
" bid_qty + ask_qty\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "7f24aa45-3a6a-47bc-a6c0-7150d33d96fe",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from matplotlib import pyplot as plt\n",
"\n",
"start = 35000\n",
"end = 40000\n",
"\n",
"ts = pl.Series(\"timestamp\", local_ts)\n",
"ts_dt = ts.cast(pl.Datetime('ns'))\n",
"\n",
"plt.plot(ts_dt[start:end], vamp[start:end])\n",
"plt.plot(ts_dt[start:end], vamp_eff[start:end])\n",
"plt.plot(ts_dt[start:end], mid_tick[start:end] * tick_size)\n",
"plt.legend(['VAMP', 'VAMP$_{effective}$', 'Mid Price'])"
]
},
{
"cell_type": "markdown",
"id": "478b4756-2765-4c5f-adf9-19b0194c8026",
"metadata": {},
"source": [
"## Accelerated Backtesting - Order Book Imbalance\n",
"\n",
"Using the precomputed order book imbalance, we perform accelerated backtesting. The only modification is that quoting based on `mid_tick` is replaced with `fair_px_tick`. \n",
"\n",
"$VAMP_{effective}$ is selected for demonstration purposes. As illustrated in [Market Making with Alpha - Order Book Imbalance](https://hftbacktest.readthedocs.io/en/latest/tutorials/Market%20Making%20with%20Alpha%20-%20Order%20Book%20Imbalance.html), there are many different ways to compute order book imbalance. The key is to identify which formulation provides the stronger signal and which parameters lead to better performance, as these may vary depending on the strategy and how the signal is monetized.\n",
"\n",
"At the end of this section, you can observe that performance improves compared to `mid_tick`; however, it is ultimately necessary to evaluate results over longer periods. Such comparisons and analyses require repeated, iterative backtesting — made feasible through this accelerated backtesting framework."
]
},
{
"cell_type": "code",
"execution_count": 36,
"id": "2c27de3b-806b-479b-982d-104f81f685bf",
"metadata": {},
"outputs": [],
"source": [
"@njit\n",
"def accelerated_backtest(\n",
" fair_px_tick,\n",
" relative_half_spread,\n",
" skew,\n",
" order_notional_value,\n",
" max_notional_position,\n",
" fee,\n",
" tick_size,\n",
" lot_size,\n",
" local_ts,\n",
" best_bid_tick,\n",
" best_ask_tick,\n",
" bid_fill_tick,\n",
" ask_fill_tick,\n",
" order_ack_ts,\n",
" bid_fill_tick_ack,\n",
" ask_fill_tick_ack,\n",
" best_bid_tick_ack,\n",
" best_ask_tick_ack,\n",
" bid_fill_tick_after_ack,\n",
" ask_fill_tick_after_ack\n",
"):\n",
" # req_bid_tick: bid order price in ticks (limit buy order with GTX) sent to the exchange, before the exchange acknowledges it.\n",
" # req_ask_tick: ask order price in ticks (limit sell order with GTX) sent to the exchange, before the exchange acknowledges it.\n",
" # open_bid_tick: bid order price in ticks acknowledged by the exchange, currently an open order in the market.\n",
" # open_ask_tick: ask order price in ticks acknowledged by the exchange, currently an open order in the market.\n",
" #\n",
" # INVALID_MIN and INVALID_MAX indicate that there are no orders.\n",
" #\n",
" # Example:\n",
" # If req_bid_tick is INVALID_MIN and there is an open bid order, \n",
" # the open bid order will be canceled (if the cancel request reaches the exchange before the order is filled).\n",
" # When an order is filled, its price is set to INVALID_MIN or INVALID_MAX accordingly.\n",
" req_bid_tick = open_bid_tick = INVALID_MIN\n",
" req_ask_tick = open_ask_tick = INVALID_MAX\n",
" # corresponding order quantities.\n",
" open_bid_qty = req_bid_qty = 0.0\n",
" open_ask_qty = req_ask_qty = 0.0\n",
"\n",
" # Initial state.\n",
" balance = 0.0\n",
" position = 0.0\n",
" num_trades = 0\n",
" trading_value = 0.0\n",
" trading_volume = 0.0\n",
"\n",
" # Row index iterator\n",
" t = 0\n",
"\n",
" # State record for stats\n",
" rec_i = 0\n",
" record = np.empty(len(local_ts), record_dtype)\n",
" \n",
" while True:\n",
" #--------------------------------------------------------\n",
" # Local bot logic at `local_ts[t]`.\n",
" mid_tick = (best_bid_tick[t] + best_ask_tick[t]) / 2.0\n",
" mid_px = mid_tick * tick_size\n",
" \n",
" notional_position_value = position * mid_px\n",
" normalized_position = notional_position_value / max_notional_position\n",
"\n",
" relative_bid_depth = relative_half_spread + skew * normalized_position\n",
" relative_ask_depth = relative_half_spread - skew * normalized_position\n",
" \n",
" req_bid_tick = min(np.floor(fair_px_tick[t] * (1.0 - relative_bid_depth)), best_bid_tick[t])\n",
" req_ask_tick = max(np.ceil(fair_px_tick[t] * (1.0 + relative_ask_depth)), best_ask_tick[t])\n",
"\n",
" req_bid_qty = req_ask_qty = max(round(order_notional_value / mid_px / lot_size) * lot_size, lot_size)\n",
" \n",
" # If the position exceeds the risk limit (max notional position),\n",
" # no orders shall be open in that direction.\n",
" if normalized_position > 1:\n",
" req_bid_tick = INVALID_MIN\n",
" if normalized_position < -1:\n",
" req_ask_tick = INVALID_MAX\n",
"\n",
" #--------------------------------------------------------\n",
" # Records the current state.\n",
" record[rec_i].timestamp = local_ts[t]\n",
" record[rec_i].price = mid_tick * tick_size\n",
" record[rec_i].position = position\n",
" record[rec_i].balance = balance * tick_size\n",
" record[rec_i].fee = trading_value * tick_size * fee\n",
" record[rec_i].num_trades = num_trades\n",
" record[rec_i].trading_volume = trading_volume\n",
" record[rec_i].trading_value = trading_value * tick_size\n",
" \n",
" rec_i += 1\n",
"\n",
" #--------------------------------------------------------\n",
" # Processes the exchange-side logic (order fill logic).\n",
" \n",
" # If any of the requested order prices differ from the open order's price,\n",
" # it is assumed that the bot sent the order request.\n",
" # The request will be acknowledged and processed at `order_ack_ts[t]`.\n",
" # Otherwise, check if the open order is filled.\n",
" if req_bid_tick != open_bid_tick or req_ask_tick != open_ask_tick:\n",
" # The current time is `order_ack_ts[t]`.\n",
" order_ack_ts_ = order_ack_ts[t]\n",
"\n",
" # If there are open orders with valid prices,\n",
" # checks whether they are filled before accepting the newly requested orders.\n",
" if open_bid_tick > INVALID_MIN and open_bid_tick >= bid_fill_tick_ack[t]:\n",
" execute_value = open_bid_tick * open_bid_qty\n",
" balance -= execute_value\n",
" position += open_bid_qty\n",
" num_trades += 1\n",
" trading_volume += open_bid_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_bid_tick = INVALID_MIN\n",
" if open_ask_tick < INVALID_MAX and open_ask_tick <= ask_fill_tick_ack[t]:\n",
" execute_value = open_ask_tick * open_ask_qty\n",
" balance += execute_value\n",
" position -= open_ask_qty\n",
" num_trades += 1\n",
" trading_volume += open_ask_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_ask_tick = INVALID_MAX\n",
" \n",
" # New orders are treated as GTX. \n",
" # If the requested buy order price is greater than or equal to the best ask,\n",
" # or the requested sell order price is less than or equal to the best bid, \n",
" # the orders are rejected.\n",
" # Invalidates the price if the order is rejected.\n",
" if req_bid_tick >= best_ask_tick_ack[t]:\n",
" req_bid_tick = INVALID_MIN\n",
" if req_ask_tick <= best_bid_tick_ack[t]:\n",
" req_ask_tick = INVALID_MAX\n",
"\n",
" # Updates the open orders to reflect accepted orders.\n",
" open_bid_tick = req_bid_tick\n",
" open_ask_tick = req_ask_tick\n",
" open_bid_qty = req_bid_qty\n",
" open_ask_qty = req_ask_qty\n",
"\n",
" # If there are open orders with valid prices,\n",
" # checks whether they are filled before the next local timestamp (`local_ts[t+n]`)\n",
" # that is greater than the current timestamp (`order_ack_ts[t]`).\n",
" if open_bid_tick > INVALID_MIN and open_bid_tick >= bid_fill_tick_after_ack[t]:\n",
" execute_value = open_bid_tick * open_bid_qty\n",
" balance -= execute_value\n",
" position += open_bid_qty\n",
" num_trades += 1\n",
" trading_volume += open_bid_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_bid_tick = INVALID_MIN\n",
" if open_ask_tick < INVALID_MAX and open_ask_tick <= ask_fill_tick_after_ack[t]:\n",
" execute_value = open_ask_tick * open_ask_qty\n",
" balance += execute_value\n",
" position -= open_ask_qty\n",
" num_trades += 1\n",
" trading_volume += open_ask_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_ask_tick = INVALID_MAX\n",
"\n",
" # The next local timestamp must be greater than the current timestamp (`order_ack_ts[t]`).\n",
" while t < len(local_ts) and local_ts[t] < order_ack_ts_:\n",
" t += 1\n",
" # Breaks if no more rows remain for processing.\n",
" if t == len(local_ts):\n",
" break\n",
" else:\n",
" # Checks if the open orders are filled between two local timestamps.\n",
" # The next row of data contains the bid fill price (in ticks) and ask fill price (in ticks) \n",
" # for that interval (step).\n",
" t += 1\n",
" # Breaks if no more rows remain for processing.\n",
" if t == len(local_ts):\n",
" break\n",
"\n",
" # # If there are open orders with valid prices, checks if they are filled.\n",
" if open_bid_tick > INVALID_MIN and open_bid_tick >= bid_fill_tick[t]:\n",
" execute_value = open_bid_tick * open_bid_qty\n",
" balance -= execute_value\n",
" position += open_bid_qty\n",
" num_trades += 1\n",
" trading_volume += open_bid_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_bid_tick = INVALID_MIN\n",
" if open_ask_tick < INVALID_MAX and open_ask_tick <= ask_fill_tick[t]:\n",
" execute_value = open_ask_tick * open_ask_qty\n",
" balance += execute_value\n",
" position -= open_ask_qty\n",
" num_trades += 1\n",
" trading_volume += open_ask_qty\n",
" trading_value += execute_value\n",
" # Invalidates the price because the order is filled.\n",
" open_ask_tick = INVALID_MAX\n",
" \n",
" return record[:rec_i]"
]
},
{
"cell_type": "code",
"execution_count": 37,
"id": "de540528-4d3d-4484-9e22-369fa37802d5",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 241 ms, sys: 10.9 ms, total: 252 ms\n",
"Wall time: 250 ms\n"
]
}
],
"source": [
"%%time\n",
"\n",
"record = accelerated_backtest(\n",
" vamp_eff / tick_size,\n",
" relative_half_spread,\n",
" skew,\n",
" order_notional_value,\n",
" max_notional_position,\n",
" fee_per_value,\n",
" tick_size,\n",
" lot_size,\n",
" local_ts,\n",
" best_bid_tick,\n",
" best_ask_tick,\n",
" bid_fill_tick,\n",
" ask_fill_tick,\n",
" order_ack_ts,\n",
" bid_fill_tick_ack,\n",
" ask_fill_tick_ack,\n",
" best_bid_tick_ack,\n",
" best_ask_tick_ack,\n",
" bid_fill_tick_after_ack,\n",
" ask_fill_tick_after_ack\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "e364d324-6fb2-4aff-9a42-6af34b2efb25",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"
shape: (1, 11) start end SR Sortino Return MaxDrawdown DailyNumberOfTrades DailyTurnover ReturnOverMDD ReturnOverTrade MaxPositionValue datetime[μs] datetime[μs] f64 f64 f64 f64 f64 f64 f64 f64 f64 2025-08-01 00:00:00 2025-08-02 00:00:00 18.879569 26.861534 0.018396 0.012351 1492.0 74.602088 1.489513 0.000247 1.0547e6
"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"stats.plot()"
]
},
{
"cell_type": "markdown",
"id": "a60b0f27-239d-445e-afd5-09a47dd9af58",
"metadata": {},
"source": [
"In the next tutorial, we will explore a more generalized framework to forecasting and fair value pricing in research based on [A Comprehensive Framework for Pricing Models](https://hftbacktest.readthedocs.io/en/latest/tutorials/Market%20Making%20with%20Alpha%20-%20APT.html#A-Comprehensive-Framework-for-Pricing-Models)."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.9"
}
},
"nbformat": 4,
"nbformat_minor": 5
}